{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "id": "zpNlbEG5HWn0"
   },
   "source": [
    "# 第27章预训练语言模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "id": "waoEGAtfHWn6"
   },
   "source": [
    "## 习题27.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "id": "waoEGAtfHWn6"
   },
   "source": [
    "&emsp;&emsp;设计基于双向LSTM的预训练语言模型，假设下游任务是文本分类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tT2dkcZrHWn6"
   },
   "source": [
    "**解答：**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yQuo79vYHWn7"
   },
   "source": [
    "**解答思路：**\n",
    "\n",
    "1. 设计基于双向LSTM的预训练模型ELMo，并加载模型权重\n",
    "2. 设计基于ELMo的文本分类模型\n",
    "3. 自编程实现基于ELMo的文本分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UsRdKonCIOTr"
   },
   "source": [
    "**第1步：设计基于双向LSTM的预训练模型ELMo，并加载模型权重**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UsRdKonCIOTr"
   },
   "source": [
    "&emsp;&emsp;ELMo是一个双向LSTM模型，它首先使用大规模文本语料库进行预训练，当用于下游任务时，其输出表示通常作为上下文相关的词向量。（论文参考链接：https://arxiv.org/abs/1802.05365 ）\n",
    "\n",
    "&emsp;&emsp;ELMo有多个不同模型大小的变体，这里我们以small版本为例，详见：https://allenai.org/allennlp/software/elmo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import wget\n",
    "import os\n",
    "from allennlp.modules.elmo import Elmo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "elmo_options_file = './data/elmo_2x1024_128_2048cnn_1xhighway_options.json'\n",
    "elmo_weight_file = './data/elmo_2x1024_128_2048cnn_1xhighway_weights.hdf5'\n",
    "url = \"https://s3-us-west-2.amazonaws.com/allennlp/models/elmo/2x1024_128_2048cnn_1xhighway/elmo_2x1024_128_2048cnn_1xhighway_options.json\"\n",
    "if(not os.path.exists(elmo_options_file)):\n",
    "    wget.download(url, elmo_options_file)\n",
    "url = \"https://s3-us-west-2.amazonaws.com/allennlp/models/elmo/2x1024_128_2048cnn_1xhighway/elmo_2x1024_128_2048cnn_1xhighway_weights.hdf5\"\n",
    "if(not os.path.exists(elmo_weight_file)):\n",
    "    wget.download(url, elmo_weight_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 加载模型\n",
    "elmo = Elmo(elmo_options_file, elmo_weight_file, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Elmo(\n",
       "  (_elmo_lstm): _ElmoBiLm(\n",
       "    (_token_embedder): _ElmoCharacterEncoder(\n",
       "      (char_conv_0): Conv1d(16, 32, kernel_size=(1,), stride=(1,))\n",
       "      (char_conv_1): Conv1d(16, 32, kernel_size=(2,), stride=(1,))\n",
       "      (char_conv_2): Conv1d(16, 64, kernel_size=(3,), stride=(1,))\n",
       "      (char_conv_3): Conv1d(16, 128, kernel_size=(4,), stride=(1,))\n",
       "      (char_conv_4): Conv1d(16, 256, kernel_size=(5,), stride=(1,))\n",
       "      (char_conv_5): Conv1d(16, 512, kernel_size=(6,), stride=(1,))\n",
       "      (char_conv_6): Conv1d(16, 1024, kernel_size=(7,), stride=(1,))\n",
       "      (_highways): Highway(\n",
       "        (_layers): ModuleList(\n",
       "          (0): Linear(in_features=2048, out_features=4096, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (_projection): Linear(in_features=2048, out_features=128, bias=True)\n",
       "    )\n",
       "    (_elmo_lstm): ElmoLstm(\n",
       "      (forward_layer_0): LstmCellWithProjection(\n",
       "        (input_linearity): Linear(in_features=128, out_features=4096, bias=False)\n",
       "        (state_linearity): Linear(in_features=128, out_features=4096, bias=True)\n",
       "        (state_projection): Linear(in_features=1024, out_features=128, bias=False)\n",
       "      )\n",
       "      (backward_layer_0): LstmCellWithProjection(\n",
       "        (input_linearity): Linear(in_features=128, out_features=4096, bias=False)\n",
       "        (state_linearity): Linear(in_features=128, out_features=4096, bias=True)\n",
       "        (state_projection): Linear(in_features=1024, out_features=128, bias=False)\n",
       "      )\n",
       "      (forward_layer_1): LstmCellWithProjection(\n",
       "        (input_linearity): Linear(in_features=128, out_features=4096, bias=False)\n",
       "        (state_linearity): Linear(in_features=128, out_features=4096, bias=True)\n",
       "        (state_projection): Linear(in_features=1024, out_features=128, bias=False)\n",
       "      )\n",
       "      (backward_layer_1): LstmCellWithProjection(\n",
       "        (input_linearity): Linear(in_features=128, out_features=4096, bias=False)\n",
       "        (state_linearity): Linear(in_features=128, out_features=4096, bias=True)\n",
       "        (state_projection): Linear(in_features=1024, out_features=128, bias=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (_dropout): Dropout(p=0.5, inplace=False)\n",
       "  (scalar_mix_0): ScalarMix(\n",
       "    (scalar_parameters): ParameterList(\n",
       "        (0): Parameter containing: [torch.FloatTensor of size 1]\n",
       "        (1): Parameter containing: [torch.FloatTensor of size 1]\n",
       "        (2): Parameter containing: [torch.FloatTensor of size 1]\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elmo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UEs7rScQcVXm"
   },
   "source": [
    "&emsp;&emsp;从模型结构可以看到，ELMO主要由一个token编码器、一个双向双层LSTM和输出层构成。其中token编码器为输入的token计算输入向量表示，然后双向双层LSTM计算隐层（状态），最后，输出层将输入向量表示以及两层LSTM的隐层（状态）进行混合，得到最后的输出表示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymFQJbs_HWn8"
   },
   "source": [
    "**第2步：设计基于ELMo的文本分类模型**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymFQJbs_HWn8"
   },
   "source": [
    "&emsp;&emsp;文本分类模型主要由预训练模型ELMo、基于双向LSTM的编码器、全连接层分类器三部分组成。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymFQJbs_HWn8"
   },
   "source": [
    "&emsp;&emsp;假设输入单词序列是$\\text{x} = \\{\\text{x}_1, \\text{x}_2, \\cdots, \\text{x}_l$\\}，输出是类别 $\\text{y}$，文本分类任务旨在计算条件概率 $P(\\text{y}|\\text{x}) = P(\\text{y}|\\text{x}_1, \\text{x}_2, \\cdots, \\text{x}_l)$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymFQJbs_HWn8"
   },
   "source": [
    "&emsp;&emsp;首先，将单词序列 $\\text{x}$ 输入到预训练模型ELMo，获得每个token的输入表示$x = \\{x_1, x_2, \\cdots, x_l$ \\}。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymFQJbs_HWn8"
   },
   "source": [
    "&emsp;&emsp;结合习题25.4，基于双向LSTM的编码器如下所示："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7KQP3wPEHWn8"
   },
   "source": [
    "&emsp;&emsp;前向的LSTM的隐层（状态）:\n",
    "$$\n",
    "h_t^f = \\text{LSTM}_f (x_t, h_{t-1}^f)\n",
    "$$\n",
    "\n",
    "&emsp;&emsp;后向的LSTM的隐层（状态）:\n",
    "$$\n",
    "h_t^b = \\text{LSTM}_b (x_t, h_{t+1}^b)\n",
    "$$\n",
    "\n",
    "其中，$\\text{LSTM}_f$ 和 $\\text{LSTM}_b$ 分别表示前向LSTM和后向LSTM，$h_{t-1}^f$ 和 $h_{t+1}^b$ 分别表示前向LSTM和后向LSTM的上一个位置的隐藏状态。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1G13vlt3HWn8"
   },
   "source": [
    "这里，将两者的拼接表示为:\n",
    "$$\n",
    "h_t = [h_i^f; h_i^b]\n",
    "$$\n",
    "其中，；表示两个向量的拼接。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "04rIMfCrY6Wr"
   },
   "source": [
    "&emsp;&emsp;然后，将所有token的表示进行Mean-Pooling，得到输入单词序列$\\text{x}$的表示$h$:\n",
    "\n",
    "$$\n",
    "h = \\text{Mean-Pool}(h_1, h_2, \\cdots, h_l)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "04rIMfCrY6Wr"
   },
   "source": [
    "&emsp;&emsp;最后,将这一表示喂入分类器，获得每个类别的概率:\n",
    "\n",
    "$$\n",
    "p = \\text{softmax}(\\text{fc}(h)) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dVold10AiaGR"
   },
   "source": [
    "&emsp;&emsp;在训练时，通常将预训练模型ELMo的参数进行固定，然后使用交叉熵作为损失函数，优化基于双向LSTM的编码器和全连接层分类器。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D7-dA3DCHWn9"
   },
   "source": [
    "**第3步：自编程实现双向LSTM的预训练语言模型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "JjTkIP7nHWn-"
   },
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.dataset import random_split\n",
    "from torchtext.data.functional import to_map_style_dataset\n",
    "from torchtext.datasets import AG_NEWS\n",
    "from allennlp.modules.elmo import batch_to_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "f-yEKyAGHWoB"
   },
   "outputs": [],
   "source": [
    "label_pipeline = lambda x : int(x) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "Kg4pQc7eHWoB"
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "def collate_batch(batch):\n",
    "    label_list, text_list = [], []\n",
    "    for (_label, _text) in batch:\n",
    "        label_list.append(label_pipeline(_label))\n",
    "        text_list.append(_text.split())\n",
    "    label_list = torch.tensor(label_list, dtype=torch.int64)\n",
    "    return label_list.to(device), text_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "RhGwcP-gHWoB"
   },
   "outputs": [],
   "source": [
    "# 加载AG_NEWS数据集\n",
    "train_iter, test_iter = AG_NEWS(root='./data')\n",
    "train_dataset = to_map_style_dataset(train_iter)\n",
    "test_dataset = to_map_style_dataset(test_iter)\n",
    "num_train = int(len(train_dataset) * 0.95)\n",
    "split_train_, split_valid_ = \\\n",
    "    random_split(train_dataset, [num_train, len(train_dataset) - num_train])\n",
    "\n",
    "\n",
    "BATCH_SIZE = 128\n",
    "train_dataloader = DataLoader(split_train_, batch_size=BATCH_SIZE,\n",
    "                              shuffle=True, collate_fn=collate_batch)\n",
    "valid_dataloader = DataLoader(split_valid_, batch_size=BATCH_SIZE,\n",
    "                              shuffle=False, collate_fn=collate_batch)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE,\n",
    "                             shuffle=False, collate_fn=collate_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "FMLBRD10HWoC"
   },
   "outputs": [],
   "source": [
    "class TextClassifier(nn.Module):\n",
    "    def __init__(self, embedding_dim, hidden_dim, num_classes):\n",
    "        super().__init__()\n",
    "        # 使用预训练的ELMO\n",
    "        self.elmo = elmo\n",
    "\n",
    "        # 使用双向LSTM\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, bidirectional=True, batch_first=True)\n",
    "\n",
    "        # 使用线性函数进行文本分类任务\n",
    "        self.fc = nn.Linear(hidden_dim * 2, num_classes)\n",
    "\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        initrange = 0.1\n",
    "        self.fc.weight.data.uniform_(-initrange, initrange)\n",
    "        self.fc.bias.data.uniform_(-initrange, initrange)\n",
    "    \n",
    "    def forward(self, sentence_lists):\n",
    "        character_ids = batch_to_ids(sentence_lists)\n",
    "        character_ids = character_ids.to(device)\n",
    "\n",
    "        embeddings = self.elmo(character_ids)\n",
    "        embedded = embeddings['elmo_representations'][0]\n",
    "\n",
    "        x, _ = self.lstm(embedded)\n",
    "        x = x.mean(1)\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "3zh34EgtHWoC"
   },
   "outputs": [],
   "source": [
    "EMBED_DIM = 256\n",
    "HIDDEN_DIM = 64\n",
    "NUM_CLASSES = 4\n",
    "LEARNING_RATE = 1e-2\n",
    "# 由于单个epochs运行时间达到5分钟，\n",
    "# 有条件的小伙伴可以设置更多的epoch，达到更好的训练效果\n",
    "NUM_EPOCHS = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "vC-XbFOAHWoD"
   },
   "outputs": [],
   "source": [
    "model = TextClassifier(EMBED_DIM, HIDDEN_DIM, NUM_CLASSES).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "92Z_GvDxHWoD"
   },
   "outputs": [],
   "source": [
    "def train(dataloader):\n",
    "    model.train()\n",
    "\n",
    "    for idx, (label, text) in enumerate(dataloader):\n",
    "        optimizer.zero_grad()\n",
    "        predicted_label = model(text)\n",
    "        loss = criterion(predicted_label, label)\n",
    "        loss.backward()\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "RyDGi3l0HWoE"
   },
   "outputs": [],
   "source": [
    "def evaluate(dataloader):\n",
    "    model.eval()\n",
    "    total_acc, total_count = 0, 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for idx, (label, text) in enumerate(dataloader):\n",
    "            predicted_label = model(text)\n",
    "            total_acc += (predicted_label.argmax(1) == label).sum().item()\n",
    "            total_count += label.size(0)\n",
    "\n",
    "    return total_acc/total_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "4O0AtMO6HWoE"
   },
   "outputs": [],
   "source": [
    "# 使用交叉熵损失函数\n",
    "criterion = nn.CrossEntropyLoss().to(device)\n",
    "# 设置优化器\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 677
    },
    "id": "9VdHJhC9HWoF",
    "outputId": "ff49937d-fda2-48ab-e8cb-53b537b84a8d",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------------------------------------------------------\n",
      "| end of epoch   1 | time: 321.49s | valid accuracy     90.4% \n",
      "-----------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, NUM_EPOCHS + 1):\n",
    "    epoch_start_time = time.time()\n",
    "    train(train_dataloader)\n",
    "    accu_val = evaluate(valid_dataloader)\n",
    "    print('-' * 59)\n",
    "    print('| end of epoch {:3d} | time: {:5.2f}s | '\n",
    "          'valid accuracy {:8.1f}% '.format(epoch,\n",
    "                                           time.time() - epoch_start_time,\n",
    "                                           accu_val * 100))\n",
    "    print('-' * 59)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "_oPGcPsbHWoF"
   },
   "outputs": [],
   "source": [
    "ag_news_label = {1: \"World\", 2: \"Sports\", 3: \"Business\", 4: \"Sci/Tec\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "JcVF6XTZHWoG"
   },
   "outputs": [],
   "source": [
    "def predict(text):\n",
    "    with torch.no_grad():\n",
    "        output = model([text])\n",
    "        return output.argmax(1).item() + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "X4rRKBDuHWoG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a Business news\n"
     ]
    }
   ],
   "source": [
    "ex_text_str = \"\"\"\n",
    "Our younger Fox Cubs (Y2-Y4) also had a great second experience \n",
    "of swimming competition in February when they travelled over to \n",
    "NIS at the end of February to compete in the SSL Development \n",
    "Series R2 event. For students aged 9 and under these SSL \n",
    "Development Series events are a great introduction to \n",
    "competitive swimming, focussed on fun and participation whilst \n",
    "also building basic skills and confidence as students build up \n",
    "to joining the full SSL team in Year 5 and beyond.\n",
    "\"\"\"\n",
    "\n",
    "print(\"This is a %s news\" %ag_news_label[predict(ex_text_str)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W9N3Ec3oHWoH"
   },
   "source": [
    "## 习题27.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W9N3Ec3oHWoH"
   },
   "source": [
    "&emsp;&emsp;假设GPT微调的下游任务是两个文本的匹配，写出学习的目标函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A8ICO0vbHWoH"
   },
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hve-xrFPHWoH"
   },
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出GPT模型的描述\n",
    "2. 给出文本匹配任务的描述\n",
    "3. 写出GPT微调的下游任务是两个文本匹配时的学习的目标函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5eU_8FtAHWoH"
   },
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0LTkOHWFHWoH"
   },
   "source": [
    "**第1步：给出GPT模型的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eejZM8uIHWoI"
   },
   "source": [
    "&emsp;&emsp;根据书中第27章的本章概要的GPT模型的描述：\n",
    "\n",
    "> &emsp;&emsp;GPT模型的输入是单词序列，可以是一个句子或一段文章。首先经过输入层，产生初始的单词表示向量的序列。之后经过 $L$ 个Transformer解码层，得到单词表示向量的序列，GPT模型的输出是在单词序列各个位置上的条件概率。  \n",
    "> &emsp;&emsp;GPT预训练时，通过极大似然估计学习模型的参数。\n",
    "> $$\n",
    "L_{\\text{train}} = - \\sum_{i = 1}^n \\log P_{\\theta}(x_i | x_1, x_2, \\cdots, x_{i - 1})\n",
    "$$\n",
    "> &emsp;&emsp;GPT微调时，通过优化下游任务的目标函数，进一步调节模型的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8MDBXdAUHWoI"
   },
   "source": [
    "**第2步：给出文本匹配任务的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LdIT08ZNHWoI"
   },
   "source": [
    "&emsp;&emsp;根据书中第27.2.2节的文本匹配任务的描述：\n",
    "\n",
    "> &emsp;&emsp;如果下游任务是文本匹配，如判断两句话是否形成一问一答。输入单词序列是 $x_0, x_1, \\cdots, x_l$，输出是类别 $y$，仍然计算条件概率 $P(y | x_0, x_1, \\cdots, x_l)$。类别有两类，表示匹配或不匹配。这时单词序列 $x_0, x_1, \\cdots, x_l$ 是两个单词序列合成的序列，如一个问句和一个答句合并而成。以特殊字符\\<cls\\>开始，中间以特殊字符\\<sep\\>间隔，最后以特殊字符\\<sep\\>结束。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OnY3RRIbHWoI"
   },
   "source": [
    "**第3步：写出GPT微调的下游任务是两个文本匹配时的学习的目标函数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ov00EG4PHWoI"
   },
   "source": [
    "&emsp;&emsp;假设分别有两个文本，矩阵$X_1 = (x_1^{(1)}, x_2^{(1)}, \\cdots, x_{m - 1}^{(1)})$和矩阵$X_2 = (x_{m + 1}^{(2)}, x_{m + 2}^{(2)}, \\cdots, x_{m + n - 1}^{(2)})$分别表示两个文本的词嵌入的序列，矩阵$E_1=(e_1^{(1)}, e_2^{(1)}, \\cdots, e_{m - 1}^{(1)})$和矩阵$E_2=(e_{m + 1}^{(2)}, e_{m + 2}^{(2)}, \\cdots, e_{m + n - 1}^{(2)})$分别表示两个文本的位置嵌入序列。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eHZmIDxNHWoI"
   },
   "source": [
    "&emsp;&emsp;经过输入层，产生初始的单词表示向量的序列，分别表示为\n",
    "$$\n",
    "H_1^{0} = X_1 + E_1 \\\\\n",
    "H_2^{0} = X_2 + E_2\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PBpurXL2HWoI"
   },
   "source": [
    "&emsp;&emsp;将两个句子分别作为前句或后句，构造两个完整的文本：  \n",
    "- 文本1：\\<Start\\>, $x_1^{(1)}, x_2^{(1)}, \\cdots, x_{m - 1}^{(1)},$ \\<Delim\\>, $x_{m + 1}^{(2)}, x_{m + 2}^{(2)}, \\cdots, x_{m + n - 1}^{(2)}$, \\<Extract\\>\n",
    "- 文本2：\\<Start\\>, $x_{m + 1}^{(2)}, x_{m + 2}^{(2)}, \\cdots, x_{m + n - 1}^{(2)},$ \\<Delim\\>, $x_1^{(1)}, x_2^{(1)}, \\cdots, x_{m - 1}^{(1)}$, \\<Extract\\>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rV8qV1mzHWoJ"
   },
   "source": [
    "分别进行GPT预训练模型：\n",
    "$$\n",
    "H_1^{(L)} = \\text{transformer\\_decoder}([H_1^{(0)};H_2^{(0)}]) \\\\\n",
    "H_2^{(L)} = \\text{transformer\\_decoder}([H_2^{(0)};H_1^{(0)}]) \\\\\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E-kfJoeEHWoJ"
   },
   "source": [
    "将得到单词表示向量的序列进行融合，使用线性层得到GPT模型的输出：\n",
    "$$\n",
    "H'^{(L)} = H_1^{(L)} \\oplus H_2^{(L)} = (h_1'^{(L)}, h_2'^{(L)}, \\cdots h_{m + n}'^{(L)}) \\\\\n",
    "P_{\\theta}(x_i |x_1, x_2, \\cdots, x_{i - 1}) = \\text{softmax} (W_x^T h_i'^{(L)}) = \\frac{\\exp \\left ( w_{x_i}^T \\cdot h_i'^{(L)} \\right )}{\\displaystyle \\sum_{x_i} \\exp \\left (w_{x_i}^T \\cdot h_i'^{(L)} \\right )}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e3k9STWuHWoJ"
   },
   "source": [
    "在预训练阶段，目标函数是\n",
    "$$\n",
    "L_{\\text{PT}} = - \\sum_{i=1}^{m + n} \\log P_{\\theta}(x_i |x_1, x_2, \\cdots, x_{i - 1})\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zsq2ImsoHWoJ"
   },
   "source": [
    "&emsp;&emsp;微调时，下游任务是文本匹配，输入的单词序列是两个文本合的序列$x_1, x_2, \\cdots,x_{m + n}$，输出是类别$y$，以特殊字符\\<Start\\>开始，中间以特殊字符\\<Delim\\>间隔，最后以特殊字符\\<Extract\\>结束。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JWWiMvDyHWoJ"
   },
   "source": [
    "可得到微调的目标函数为\n",
    "$$\n",
    "L_{\\text{LM}} = - \\frac{1}{m + n} \\sum_{i = 1}^{m + n} \\log P_{\\theta}(y|x_1, x_2, \\cdots, x_{i - 1})\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OSuANbEcHWoJ"
   },
   "source": [
    "## 习题27.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OSuANbEcHWoJ"
   },
   "source": [
    "&emsp;&emsp;设计一个2层卷积神经网络编码器和2层卷积神经网络解码器组成的自动编码器（使用第28章介绍的转置卷积）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zb2t6Q5uHWoJ"
   },
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n_tmLh39HWoK"
   },
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出自动编码器的原理\n",
    "2. 给出转置卷积的定义\n",
    "3. 自编程实现2层卷积自动编码器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7u8yGJkSHWoK"
   },
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LevojTnFHWoK"
   },
   "source": [
    "**第1步：自动编码器的原理**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5KfOi2QpHWoK"
   },
   "source": [
    "&emsp;&emsp;根据书中第27.2.2节的自动编码器的描述：\n",
    "\n",
    "> &emsp;&emsp;自动编码器（auto encoder）是用于数据表示的无监督学习的一种神经网络。自动编码器由编码器网络和解码器网络组成。\n",
    "> 最基本的情况下，编码器和解码器分别都是一层神经网络\n",
    "> $$ z = F(x) = a(W_E x + b_E) \\\\\n",
    "y = G(z) = a(W_D x + b_D) $$\n",
    "> 其中，$W_E, W_D$是权重矩阵，$b_E, b_D$是偏置向量，$a(\\cdot)$是激活函数。  \n",
    "> &emsp;&emsp;学习时，目标函数是\n",
    "> $$ L = \\frac{1}{N} \\sum_{i=1}^N L(x_i, y_i) = \\frac{1}{N} \\sum_{i = 1}^N L(x_i, G(F(x_i))) $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "punKi_CQHWoK"
   },
   "source": [
    "**第2步： 转置卷积的定义**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UcYQQKUnHWoK"
   },
   "source": [
    "&emsp;&emsp;根据书中第28.2.1节的转置卷积的定义：\n",
    "\n",
    "> &emsp;&emsp;转置卷积（transposed convolution）也称为微步卷积（fractionally strided convolution）或反卷积（deconvolution），在图像生成网络、图像自动编码器等模型中广泛使用。卷积可以用于图像数据尺寸的缩小，而转置卷积可以用于图像数据尺寸的放大，又分别称为下采样或上采样。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "99QRJpf5HWoK"
   },
   "source": [
    "&emsp;&emsp;根据书中第28章的本章概要的转置卷积的运算：\n",
    "\n",
    "> 对于任意一个卷积运算，存在对应的线性变换的矩阵 $C$。针对转置矩阵 $C^T$，引入新的卷积运算，称为转置卷积。原始卷积和转置卷积是相互对应、互为反向的运算。原始卷积的卷积核是 $W$ 时，转置卷积的卷积核是 $\\text{rot180}(W)$。卷积核和转置卷积核之间有 $\\text{rot180}(\\text{rot180}(W)) = W$ 成立。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qMOSuDlKHWoL"
   },
   "source": [
    "**第3步：自编程实现2层卷积自动编码器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "ZEE8dTTuHWoL"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.transforms as transforms\n",
    "import tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "from torch import optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import mnist\n",
    "from torchviz import make_dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "3ysY5kL7HWoL"
   },
   "outputs": [],
   "source": [
    "class AutoEncoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(AutoEncoder, self).__init__()\n",
    "        # 2层卷积神经网络编码器\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Conv2d(1, 16, 3, 2, 1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(16, 32, 3, 2, 1),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        # 2层卷积神经网络解码器\n",
    "        self.decoder = nn.Sequential(\n",
    "            # 使用转置卷积\n",
    "            nn.ConvTranspose2d(32, 16, 3, 2, 1, output_padding=1),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            nn.ConvTranspose2d(16, 1, 3, 2, 1, output_padding=1),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.encoder(x)\n",
    "        x = self.decoder(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "MX-y4Fh-HWoL"
   },
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "# 使用MNIST数据集\n",
    "train_set = mnist.MNIST('./data', transform=transforms.ToTensor(), train=True, download=True)\n",
    "test_set = mnist.MNIST('./data', transform=transforms.ToTensor(), train=False, download=True)\n",
    "train_dataloader = DataLoader(train_set, batch_size=32, shuffle=True)\n",
    "test_dataloader = DataLoader(test_set, batch_size=8, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "mFt8PfOFHWoL"
   },
   "outputs": [],
   "source": [
    "model = AutoEncoder().to(device)\n",
    "\n",
    "# 设置损失函数\n",
    "criterion = nn.MSELoss()\n",
    "# 设置优化器\n",
    "optimizer = optim.Adam(model.parameters(), lr=1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "uKl4cEWbHWoL",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AutoEncoder(\n",
       "  (encoder): Sequential(\n",
       "    (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (3): ReLU()\n",
       "  )\n",
       "  (decoder): Sequential(\n",
       "    (0): ConvTranspose2d(32, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): ConvTranspose2d(16, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
       "    (3): Sigmoid()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 显示模型结构\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "Q3aOx4M9HWoM",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 180.98it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 188.63it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 189.27it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 178.80it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 185.14it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 187.51it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 179.53it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 186.49it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 189.39it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 189.29it/s]\n"
     ]
    }
   ],
   "source": [
    "# 模型训练\n",
    "EPOCHES = 10\n",
    "for epoch in range(EPOCHES):\n",
    "    for img, _ in tqdm.tqdm(train_dataloader, ):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        img = img.to(device)\n",
    "        out = model(img)\n",
    "        loss = criterion(out, img)\n",
    "        loss.backward()\n",
    "\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "z5Z7x7emHWoM",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x200 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x200 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x200 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 将生成图片和原始图片进行对比\n",
    "for i, data in enumerate(test_dataloader):\n",
    "    img, _ = data\n",
    "    img = img.to(device)\n",
    "    model = model.to(device)\n",
    "    img_new = model(img).detach().cpu().numpy()\n",
    "    img = img.cpu().numpy()\n",
    "    plt.figure(figsize=(8, 2))\n",
    "    for j in range(8):\n",
    "        plt.subplot(2, 8, j + 1)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(img_new[j].squeeze())\n",
    "        plt.subplot(2, 8, 8 + j + 1)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(img[j].squeeze())\n",
    "    if i >= 2:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "qR0-qnJBHWoN"
   },
   "outputs": [],
   "source": [
    "def save_model_structure(model, device):\n",
    "    x = torch.randn(1, 1, 28, 28).requires_grad_(True).to(device)\n",
    "    y = model(x)\n",
    "    vise = make_dot(y, params=dict(list(model.named_parameters()) + [('x', x)]))\n",
    "    vise.format = \"png\"\n",
    "    vise.directory = \"./data\"\n",
    "    vise.view(\"2-Layer-CNN-AutoEncoder-Struction\", cleanup=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "NedNeULcHWoN"
   },
   "outputs": [],
   "source": [
    "# 保存模型架构图\n",
    "save_model_structure(model, device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yBwLI-w_HWoN"
   },
   "source": [
    "## 习题27.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yBwLI-w_HWoN"
   },
   "source": [
    "&emsp;&emsp;证明当编码器和解码器都是线性函数时，主成分分析可以作为自动编码器学习的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p43z2xw9HWoN"
   },
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LTI5nBoLHWoN"
   },
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出主成分分析的定义\n",
    "2. 给出自动编码器学习过程\n",
    "3. 证明当编码器和解码器都是线性函数时，主成分分析可以作为自动编码器学习的方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZsPrnSnsHWoN"
   },
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4jMYaKXKHWoN"
   },
   "source": [
    "**第1步：主成分分析的定义**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oScHNCc8HWoO"
   },
   "source": [
    "&emsp;&emsp;根据书中第16章的主成分分析的基本思想：\n",
    "\n",
    "> &emsp;&emsp;主成分分析中，首先对给定数据进行规范化，使得数据每一变量的平均值为0，方差为1，之后对数据进行正交变换，原来由线性相关变量表示的数据通过正交变换变成由若干个线性无关的新变量表示的数据。新变量是可能的正交变换中变量的方差的和（信息保存）最大的，方差表示在新变量上信息的大小。将新变量依次称为第一主成分、第二主成分等。这就是主成分分析的基本思想。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tBTj79IkHWoO"
   },
   "source": [
    "&emsp;&emsp;根据书中第16.2.3节的算法16.1主成分分析算法：\n",
    "\n",
    "> **算法16.1（主成分分析算法）**  \n",
    "> 输入：$m \\times n$样本矩阵$X$，其每一行元素的均值为零；  \n",
    "> 输出：$k \\times n$样本主成分矩阵$Y$。  \n",
    "> 参数：主成分个数$k$  \n",
    "> （1）构造新的$n \\times m$矩阵\n",
    "> $$\n",
    "X' = \\frac{1}{\\sqrt{n - 1}} X^T\n",
    "$$\n",
    "> $X'$每一列的均值为零。  \n",
    "> （2）对矩阵$X'$进行截断奇异值分解，得到\n",
    "> $$\n",
    "X' = U \\Sigma V^T\n",
    "$$\n",
    "> 有$k$个奇异值、奇异向量。矩阵$V$的前$k$列构成$k$个样本主成分。  \n",
    "> （3）求$k \\times n$样本主成分矩阵\n",
    "> $$\n",
    "Y = V^T X\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2HllJmwtHWoO"
   },
   "source": [
    "**第2步：自动编码器学习过程**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NHJxdvRwHWoO"
   },
   "source": [
    "&emsp;&emsp;根据书中第27章的本章概要的自动编码器的描述：\n",
    "\n",
    "> &emsp;&emsp;自动编码器是用于数据表示的无监督学习的一种神经网络。自动编码器由编码器网络和解码器网络组成。学习时编码器将输入向量转换为中间表示向量，解码器再将中间表示向量转换为输出向量。编码器和解码器可以是\n",
    "> $$\n",
    "z = F(x) = a(W_E x + b_E) \\\\\n",
    "y = G(z) = a(W_D z + b_D)\n",
    "$$\n",
    "> 学习的目标是尽量使输出向量和输入向量保持一致，或者说重建输入向量。认为学到的中间表示向量就是数据的表示。\n",
    "> $$\n",
    "L = \\frac{1}{N} \\sum_{i = 1}^N L(x_i, G(F(x_i)))\n",
    "$$\n",
    "> 学习的算法一般是梯度下降。自动编码器学习实际进行的是对数据的压缩。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "maLXPlOEHWoO"
   },
   "source": [
    "**第3步：证明当编码器和解码器都是线性函数时，主成分分析可以作为自动编码器学习的方法**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R6W-talNHWoO"
   },
   "source": [
    "&emsp;&emsp;假设给定样本矩阵$X = (x_1, x_2, \\cdots, x_N)$，根据主成分分析算法，可以得到主成分为$K$个对应的单位特征向量$V$，样本主成分矩阵$Y$满足\n",
    "$$\n",
    "Y = V^T \\cdot X\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nslH-6t5HWoP"
   },
   "source": [
    "这样，样本主成分矩阵$Y$可以作为样本矩阵$X$的低维表示，$V$维度是$N \\times K$，其中$V = (v_1, v_2, \\cdots, v_N)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RZLRyoEwHWoP"
   },
   "source": [
    "&emsp;&emsp;根据自动编码器中的编码阶段，编码器对数据进行压缩，当编码器是线性函数时，可用主成分矩阵$Y$表示编码器的输出，即\n",
    "$$\n",
    "z = F(x) = W_E x + b_E = V^T \\cdot x\n",
    "$$\n",
    "其中$W_E = V^T, b_E = 0$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lzQJIH3EHWoP"
   },
   "source": [
    "&emsp;&emsp;在解码阶段，解码器通过解压可以得到原始数据的近似，当解码器是线性函数时，可用单位特征向量$V$表示$W_D$，即\n",
    "$$\n",
    "y = G(z) = W_D \\cdot z + b_D = V \\cdot z \n",
    "$$\n",
    "其中$W_D = V, b_D = 0$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mr0WQUmPHWoP"
   },
   "source": [
    "&emsp;&emsp;综上所述，当损失函数是平方损失函数时，自动编码器学习的目标函数是\n",
    "$$\n",
    "\\begin{aligned}\n",
    "L \n",
    "&= \\frac{1}{N} \\sum_{i=1}^N \\| x_i - G(F(x_i)) \\| \\\\\n",
    "&= \\frac{1}{N} \\sum_{i=1}^N \\| x_i - v_i \\cdot (v_i^T \\cdot x_i) \\| \\\\\n",
    "&= \\frac{1}{N} \\sum_{i=1}^N \\| x_i - v_i v_i^T x_i \\|\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bk_sJGmUHWoP"
   },
   "source": [
    "&emsp;&emsp;由于单位特征向量$V$可以使得样本矩阵$X$的所有线性变换中方差最大，故单位向量特征$V$能够使目标函数最小，因此，当编码器和解码器都是线性函数，且$b_E = b_D = 0$时，主成分分析可以作为自动编码器的学习方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EjLkO-3YHWoQ"
   },
   "source": [
    "## 习题27.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EjLkO-3YHWoQ"
   },
   "source": [
    "&emsp;&emsp;解释为什么BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tHRdTsGwHWoQ"
   },
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A6XwVS60HWoQ"
   },
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出BERT预训练中的掩码语言模型化描述\n",
    "2. 给出去噪自动编码器的原理\n",
    "3. 解释BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的原因"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F7dIntKpHWoQ"
   },
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yneyya2VHWoQ"
   },
   "source": [
    "**第1步：BERT预训练中的掩码语言模型化的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r_HQ3LTLHWoQ"
   },
   "source": [
    "&emsp;&emsp;根据书中第27.2.2节的关于BERT预训练中的掩码语言模型化的描述：\n",
    "\n",
    "> &emsp;&emsp;BERT模型的预训练由两部分组成，掩码语言模型化和下句预测。掩码语言模型化的目标是复原输入单词序列中被掩码的单词。可以看作是去噪自动编码器学习，对被掩码的单词独立地进行复原。掩码单词序列表示为$\\tilde{x}$。  \n",
    "> &emsp;&emsp;掩码语言模型化在每一个掩码位置计算条件概率：\n",
    "> $$ P_{\\theta} (x_i | \\tilde{x}_0, \\tilde{x}_1, \\cdot, \\tilde{x}_{m + n}) = \\text{softmax} \\left( W_x^T h_i^{(L)} \\right) = \\frac{\\exp \\left( w_{x_i}^T \\cdot h_i^{(L)} \\right)}{\\displaystyle \\sum_{x'_i} \\exp \\left( w_{x_i}^T \\cdot h_i^{(L)} \\right)} $$\n",
    "> 假设第$i$个位置是掩码位置，$h_i^{(L)}$是在第$L$层第$i$个位置的表示，$x_i$是预测的单词，$W_{x}$是单词的权重矩阵。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SYtzyGv4HWoQ"
   },
   "source": [
    "**第2步：去噪自动编码器的原理**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "euetI50zHWoR"
   },
   "source": [
    "&emsp;&emsp;根据书中第27章的本章概要的去噪自动编码器的描述：\n",
    "\n",
    "> &emsp;&emsp;去噪自动编码器是自动编码器的一种扩展，去噪自动编码器不仅可以用于数据表示学习，而且可以用户数据去噪。学习时首先根据对输入向量进行的随机变化，得到有噪声的输入向量。编码器将有噪声的输入向量转换为中间表示向量，解码器再将中间表示向量转换为输出向量。编码器、解码器、目标函数分别是\n",
    "> $$ z = F(x) = a(W_E \\tilde{x} + b_E) \\\\\n",
    "y = G(z) = a(W_D z + b_D) \\\\\n",
    "L = \\frac{1}{N} \\sum_{i = 1}^N L(x_i, G(F(\\tilde(x)_i))) $$\n",
    "> 学习的目标是尽量使输出向量和原始输入向量保持一致，或者说重建原始输入向量。因为学习的目标是排除噪声的干扰重建数据，去噪自动编码器能更有效地学到数据的主要特征。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HUWvSl7tHWoR"
   },
   "source": [
    "**第3步：解释BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的原因**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OfYMepJqHWoR"
   },
   "source": [
    "&emsp;&emsp;BERT在预训练阶段，输入序列中的一些单词被随机遮掩，掩盖单词的过程相当于向输入序列中添加了一些噪声，得到有噪声的输入向量，模型需要预测并复原这些单词。这个过程类似于去噪自动编码器的学习过程，其中模型需要从缺失的或噪声的数据中重构原始数据。因此，掩码语言模型化提供了一些“噪音”，让模型学会从不完整的输入中推断出缺失的信息，从而提高模型的泛化能力。这也就说明了BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B071n_ZwHWoR"
   },
   "source": [
    "## 习题27.6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B071n_ZwHWoR"
   },
   "source": [
    "&emsp;&emsp;比较BERT与Transformer编码器在模型上的异同。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WPzxpNZuHWoR"
   },
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qjU05u9GHWoR"
   },
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出BERT的模型描述\n",
    "2. 给出Transformer编码器的模型描述\n",
    "3. 比较BERT与Transformer编码器在模型上的异同"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8PWM-glnHWoR"
   },
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hKOB64FuHWoS"
   },
   "source": [
    "**第1步：BERT模型的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tkrlcH-fHWoS"
   },
   "source": [
    "&emsp;&emsp;根据书中第27.2.2节的关于BERT的描述：\n",
    "\n",
    "> &emsp;&emsp;BERT是双向Transformer编码器表示（Bidirectional Encoder Representations from Transformers）的缩写。BERT的模型基于Transformer的编码器，是双向语言模型。BERT的预训练主要是掩码语言模型化，使用大规模语料基于自去噪自动编码器原理进行模型的参数估计，学习的目标是复原给定的掩码单词序列中被掩码的每一个单词。学习和预测都是非自回归过程（Non-autoregressive process）。\n",
    "> &emsp;&emsp;每一个单词序列是一个句子或一段文章。首先经过输入层，产生初始的单词表示向量的序列，记作矩阵$H^{(0)}$：\n",
    "> $$ H^{(0)} = X + S + E \\tag{27.22} $$\n",
    "> 其中，矩阵$X$表示单词的词嵌入的序列$X = (x_0, x_1, \\cdots, x_{m + n})$；矩阵$E$表示单词的位置嵌入的序列$E=(e_0, e_1, \\cdots, e_{m + n})$；矩阵$S$是区别前后单词的标记序列$S=(a, a, \\cdots, a, b, b, \\cdots, b)$，含有$m + 1$个向量$a$和$n$个向量$b$。$X,E,S,H^{(0)}$是$d \\times (m + n + 1)$矩阵，设词嵌入、位置嵌入、标记向量的维度是$d$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uGR8dxWUHWoS"
   },
   "source": [
    "&emsp;&emsp;根据书中第27章的本章概要的BERT模型的描述：\n",
    "\n",
    "> &emsp;&emsp;BERT模型的输入是两个合并的单词序列。首先经过输入层，产生初始的单词表示向量的序列。之后经过$L$个Transformer编码层，得到单词的表示向量的序列。BERT模型的输出是在单词序列的各个位置上的条件概率。  \n",
    "> &emsp;&emsp;BERT模型的预训练由掩码语言模型化和下句预测组成。掩码语言模型化的目标是复原输入单词序列中被掩码的单词。下句预测的目标是判断输入单词序列是否来自同一篇文章。预训练以掩码语言模型化为主，其损失函数是\n",
    "> $$ L_1 = - \\sum_{i = 0}^{m + n} \\delta_i \\log P_{\\theta} (x_i | \\tilde{x}_0, \\tilde{x}_1, \\cdots, \\tilde{x}_{m + n}) $$\n",
    "> &emsp;&emsp;BERT微调时，通过优化下游任务的目标函数，进一步调节模型的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YBGTGGaJHWoS"
   },
   "source": [
    "**第2步：Transformer编码器的模型描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6EpQqmJUHWoS"
   },
   "source": [
    "&emsp;&emsp;根据书中第26.3.1节关于Transformer编码器的描述：  \n",
    "\n",
    "> &emsp;&emsp;Transformer（转换器）由编码器和解码器组成。编码器有1个输入层、6个编码层（一般是$L$层）。解码器有1个输入层、6个解码层、1个输出层。编码器的输入层与第1个编码层连接，第1个编码层再与第2个编码层连接，依次连接，直到第6个编码层。解码器的输入层与第1个解码层连接，第1个解码层再与第2个解码层连接，依次连接，直到第6个解码层。第6个解码层再与输出层连接。第6个编码层与各个解码层之间也有连接。  \n",
    "> &emsp;&emsp;编码器的6个编码层将输入单词序列进行转换，得到中间表示序列。  \n",
    "> &emsp;&emsp;编码器的6个编码层有相同的结构，每一个编码层由自注意力子层和前馈网络子层两部分组成。  \n",
    "> &emsp;&emsp;在编码器的输入层，输入序列的各个位置有单词的词嵌入（word embedding）和位置嵌入（position embedding），其中位置嵌入表示在序列中的位置。在每一个位置以词嵌入和位置嵌入的和作为该位置的输入向量。单词的词嵌入通常通过对单词的独热向量进行一个线性变化得到，即用一个矩阵乘以独热向量，矩阵称为词嵌入矩阵。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lvzayYDZHWoS"
   },
   "source": [
    "&emsp;&emsp;根据书中第26.3.1节关于Transformer编码器计算公式：\n",
    "> &emsp;&emsp;在编码器的输入层通过线性变换获得单词的词嵌入。\n",
    "> $$ e = W_e \\cdot w \\tag{26.26} $$\n",
    "> 其中，$w$是单词的独热向量，$e$是单词的词嵌入，$W_e$是嵌入矩阵。嵌入矩阵在学习中自动获得。  \n",
    "> &emsp;&emsp;编码器的输入层的每一个位置的输入向量是\n",
    "> $$ e + p \\tag{26.27} $$\n",
    "> 其中，$e$是该位置的词嵌入，$p$是该位置的位置嵌入。  \n",
    "> &emsp;&emsp;编码器的每一层的每一个位置的前馈网络是\n",
    "> $$ \\text{ffn} (z) = W_2 \\text{relu} (W_1 z + b_1) + b_2 \\tag{26.28} $$\n",
    "> 其中，$W_1$和$W_2$是权重矩阵，$b_1$和$b_2$是偏置向量。  \n",
    "> &emsp;&emsp;编码器的每一层的每一个位置的层归一化函数是\n",
    "> $$ \\text{norm} (z) = \\gamma \\frac{z - u \\cdot \\boldsymbol{1}}{\\sqrt{\\sigma^2 + \\varepsilon}} + \\beta \\cdot \\boldsymbol{1} $$\n",
    "> 其中，$u$是均值，$\\sigma^2$是方差，$\\gamma$和$\\beta$是参数，$\\varepsilon$是常量。  \n",
    "> &emsp;&emsp;编码器的输入层的计算可以写作\n",
    "> $$ H_E^{(0)} = E_E + P_E \\tag{26.31} $$\n",
    "> &emsp;&emsp;编码器的第$l$个编码器的多头自注意力子层和前馈网络子层计算可以写作\n",
    "> $$ Z_E^{(l)} = \\text{norm} (H_E^{(l - 1)} + \\text{multi\\_attend} (H_E^{(l - 1)}, H_E^{(l - 1)}, H_E^{(l - 1)})) \\tag{26.32} $$\n",
    "> $$ H_E^{(l)} = \\text{norm} (Z_E^{(l)} + \\text{ffn} (Z_E^{(l)})) \\tag{26.33} $$\n",
    "> 其中，$H_E^{(l)}$是第$l$个编码层的所有位置的输出，$H_E^{(l - 1)}$是所有位置的输入，$Z_E^{(l)}$是中间结果；$\\text{ffn}()$和$\\text{norm}()$的计算针对矩阵的每一列，$\\text{multi\\_attend()}$的计算针对矩阵整体进行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9aIlF38yHWoS"
   },
   "source": [
    "**第3步：比较BERT与Transformer编码器在模型上的异同**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XkVXUMVmHWoT"
   },
   "source": [
    "- 相同点：\n",
    "    1. 两者都是基于多头注意力机制的架构设计，使用了自注意力机制来处理输入序列。\n",
    "    2. 两者都使用了残差连接和层归一化。\n",
    "    3. 两者都可以使用预训练技术提高模型的泛化能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G0B504HEHWoT"
   },
   "source": [
    "- 不同点：\n",
    "    1. BERT模型在Transformer模型的基础上添加了掩码语言模型和下句预测任务。\n",
    "    2. BERT模型在训练的时候会在其后添加线性层和softmax层，用于预测掩码语言模型和下句预测任务；Transformer编码器则是直接和Transformer解码器连接，用于预测序列的下一个单词。\n",
    "    3. BERT模型中输入序列的嵌入由词嵌入、位置嵌入、区别前后单词的标记序列的和组成；Transformer编码器模型的输入序列的嵌入由词嵌入、位置嵌入的和组成。\n",
    "    4. BERT模型使用了双向语言模型，能够同时处理输入序列的左右两个方向；Transformer编码器通常只处理从左到右的输入序列。\n",
    "    5. BERT模型的位置嵌入通过学习得到；Transformer的位置嵌入由公式计算得到。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 参考文献"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "【1】Matthew E. Peters and Mark Neumann and Mohit Iyyer and Matt Gardner and Christopher Clark and Kenton Lee and Luke Zettlemoyer. 2018. Deep contextualized word representations. arXiv, abs/1802.05365  \n",
    "【2】ELMo：https://allenai.org/allennlp/software/elmo  "
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "gpuClass": "standard",
  "interpreter": {
   "hash": "c50c7698ff25eb1d7dce4c52e3d5cc14b3b23d6a97d4fb70aad8c815eba6f63e"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "273.188px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
